import { store } from '@/store';
import DictAPI from '@/api/admin/admin/dict';
import { isEqual } from 'lodash-es';
import localforage from 'localforage'; // 导入 localforage

// 初始化 localforage 实例
const dictStore = localforage.createInstance({
  name: 'dictionaryStore', // 数据库名称
  storeName: 'dictionaries', // 对象存储（表）名称
  description: '存储字典数据',
});

export const useDictStore = defineStore('dict', () => {
  const dictionary = ref(new Map());
  const pendingRequests = new Map();

  // 初始化加载本地缓存
  const initFromStorage = async () => {
    // 改为异步
    try {
      // 从 IndexedDB 获取所有数据
      const keys = await dictStore.keys();
      for (const key of keys) {
        const item = await dictStore.getItem(key);
        dictionary.value.set(key, item);
      }
      console.log('字典数据从 IndexedDB 加载成功');
    } catch (e) {
      console.error('从 IndexedDB 加载字典数据失败，重置存储', e);
      await dictStore.clear(); // 清空 IndexedDB
    }
  };

  // 持久化到本地存储 (IndexedDB)
  const saveToStorage = async (code, data) => {
    // 接收 code 和 data
    try {
      if (code && data) {
        await dictStore.setItem(code, data); // 存储单个字典项
      } else {
        // 如果没有指定 code 和 data，则遍历 Map 存储所有
        // 注意：这种全量存储在数据量大时效率不高，通常只更新变化的部分
        for (const [key, value] of dictionary.value.entries()) {
          await dictStore.setItem(key, value);
        }
      }
      console.log(`字典数据 [${code || '全部'}] 保存到 IndexedDB 成功`);
    } catch (e) {
      console.error('保存字典数据到 IndexedDB 失败', e);
    }
  };

  // 设置字典数据（带类型校验）
  const setDictionary = async (dict) => {
    // 改为异步
    const normalizedCode = dict.code.trim().toLowerCase();
    // 值未变化时跳过更新
    if (isEqual(dictionary.value.get(normalizedCode), dict.dictDatas)) return;

    dictionary.value.set(normalizedCode, dict.dictDatas);
    await saveToStorage(normalizedCode, dict.dictDatas); // 只保存当前更新的项
  };

  const loadDictionaries = async () => {
    const { data: dictList } = await DictAPI.getDictList();
    const updates = new Map();

    dictList.forEach((dict) => {
      const code = dict.code?.trim().toLowerCase();
      if (code) updates.set(code, dict.sql);
    });

    // 批量更新内存 Map
    updates.forEach((value, key) => dictionary.value.set(key, value));

    // 批量更新 IndexedDB
    for (const [key, value] of updates.entries()) {
      await saveToStorage(key, value);
    }
    console.log('所有字典数据从 API 加载并保存到 IndexedDB 成功');
  };

  // 获取字典数据
  const getDictionary = async (code, perms = false) => {
    const normalizedCode = code?.trim().toLowerCase();

    if (pendingRequests.has(normalizedCode)) {
      return Promise.race([
        pendingRequests.get(normalizedCode),
        new Promise((_, reject) =>
          setTimeout(() => reject(new Error('请求超时')), 5000),
        ),
      ]);
    }

    if (!normalizedCode) return [];

    // 缓存检查 (内存 Map)
    if (
      dictionary.value.has(normalizedCode) &&
      dictionary.value.get(normalizedCode).length > 0
    ) {
      return dictionary.value.get(normalizedCode);
    }

    // 尝试从 IndexedDB 加载 (如果内存中没有)
    try {
      const storedData = await dictStore.getItem(normalizedCode);
      if (storedData && storedData.length > 0) {
        dictionary.value.set(normalizedCode, storedData); // 加载到内存
        console.log(`字典 [${normalizedCode}] 从 IndexedDB 加载成功`);
        return storedData;
      }
    } catch (e) {
      console.error(`从 IndexedDB 加载字典 [${normalizedCode}] 失败`, e);
    }

    // 请求锁机制 (保持不变)
    if (pendingRequests.has(normalizedCode)) {
      return await pendingRequests.get(normalizedCode);
    }

    // 发起新请求
    const requestPromise = DictAPI.getDictData({
      code: normalizedCode,
      perms,
    })
      .then(async ({ data }) => {
        // 确保这里是 async
        await setDictionary({
          // 等待 setDictionary 完成
          code: normalizedCode,
          dictDatas: data,
        });
        return data;
      })
      .catch((error) => {
        console.error(`字典[${normalizedCode}]加载失败:`, error);
        return [];
      })
      .finally(() => {
        pendingRequests.delete(normalizedCode);
      });

    pendingRequests.set(normalizedCode, requestPromise);
    return requestPromise;
  };

  // 清理字典数据缓存
  const clearDictionaryCache = async () => {
    // 改为异步
    dictionary.value.clear(); // 清空内存 Map
    await dictStore.clear(); // 清空 IndexedDB
    console.log('字典缓存已清空 (内存和 IndexedDB)');
  };

  // 更新字典数据缓存
  const updateDictionaryCache = async () => {
    // 改为异步
    dictionary.value.clear(); // 清空内存 Map
    // 不需要清空 IndexedDB，直接覆盖即可
    await loadDictionaries();
  };

  // 刷新字典数据缓存
  const refreshDictionaryCache = async () => {
    // 改为异步
    dictionary.value.clear(); // 清空内存 Map
    await dictStore.clear(); // 清空 IndexedDB
    await loadDictionaries();
  };

  // 新增：单独删除一个字典项（内存和 IndexedDB）
  const removeDictionary = async (code) => {
    if (!code) {
      console.warn('删除字典失败：未提供 code');
      return;
    }
    const normalizedCode = code.trim().toLowerCase();

    // 1. 从内存 Map 中删除
    if (dictionary.value.has(normalizedCode)) {
      dictionary.value.delete(normalizedCode);
      console.log(`字典 [${normalizedCode}] 已从内存中删除`);
    }

    // 2. 从 IndexedDB 中删除
    try {
      await dictStore.removeItem(normalizedCode);
      console.log(`字典 [${normalizedCode}] 已从 IndexedDB 中删除`);
    } catch (e) {
      console.error(`从 IndexedDB 删除字典 [${normalizedCode}] 失败`, e);
    }
  };

  // 新增：强制更新单个字典项
  const updateDictionary = async (code, perms = false) => {
    if (!code) {
      console.warn('更新字典失败：未提供 code');
      return null;
    }
    const normalizedCode = code.trim().toLowerCase();

    console.log(`正在强制更新字典 [${normalizedCode}]...`);

    try {
      // 直接调用 API 获取最新数据
      const { data } = await DictAPI.getDictData({
        code: normalizedCode,
        perms,
      });

      // 使用 setDictionary 更新内存和 IndexedDB
      await setDictionary({
        code: normalizedCode,
        dictDatas: data,
      });

      console.log(`字典 [${normalizedCode}] 已成功更新并存入缓存。`);
      return data; // 返回更新后的数据
    } catch (error) {
      console.error(`字典 [${normalizedCode}] 更新失败:`, error);
      // 可选：如果更新失败，是否要删除旧的缓存？
      // await removeDictionary(normalizedCode); // 避免脏数据
      return null;
    }
  };

  // 初始化 (确保在 defineStore 内部调用，或者在组件挂载后调用)
  // 注意：initFromStorage 是异步的，需要确保在其他操作前完成
  // 可以在 setup 函数中 await initFromStorage()
  initFromStorage();

  return {
    dictionary,
    setDictionary,
    getDictionary,
    loadDictionaries,
    clearDictionaryCache,
    updateDictionaryCache,
    refreshDictionaryCache,
    removeDictionary,
    updateDictionary,
  };
});

export function useDictStoreHook() {
  return useDictStore(store);
}
